package cn.rxls.community.service.impl;

import cn.rxls.community.dto.contractual.AddContractualDTO;
import cn.rxls.community.dto.contractual.ContractAssetConfirmDTO;
import cn.rxls.community.dto.contractual.ContractConfirmDTO;
import cn.rxls.community.dto.contractual.PageContractualByStateDTO;
import cn.rxls.community.entity.Contractual;
import cn.rxls.community.enums.ContractualAssetEnum;
import cn.rxls.community.enums.ContractualStateEnum;
import cn.rxls.community.enums.ContractualimportantEnum;
import cn.rxls.community.enums.ResultEnum;
import cn.rxls.community.exception.BusinessException;
import cn.rxls.community.mapper.ContractualMapper;
import cn.rxls.community.service.ContractualService;
import cn.rxls.community.util.DesensitizationUtil;
import cn.rxls.community.util.HttpUtil;
import cn.rxls.community.vo.ContractualVO;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * 房屋合同(Contractual)表服务实现类
 */
@Service("contractualService")
@Transactional
public class ContractualServiceImpl extends ServiceImpl<ContractualMapper, Contractual> implements ContractualService {

    private final ContractualMapper contractualMapper;

    ContractualServiceImpl(ContractualMapper contractualMapper) {
        this.contractualMapper = contractualMapper;
    }

    /**
     * 新增合同
     *
     * @param dto 参数对象
     * @return 是否成功
     */
    @Override
    public Boolean addContracting(AddContractualDTO dto) {
        String uid = String.valueOf(HttpUtil.getUserLoginInfo().get("uid"));
        //合同编号
        String[] number = dto.getHouseNumber().split("-");
        String contractingNumber = createContractingNumber(number[1], dto.getCommunity(), dto.getPlaceContract());

        Contractual contractual = new Contractual();
        BeanUtils.copyProperties(dto, contractual);

        contractual.setContractualNumber(contractingNumber);
        contractual.setContractualState(ContractualStateEnum.NOT_SIGNED.code);
        contractual.setAssetConfirm(ContractualAssetEnum.NOT.code);
        contractual.setImportantConfirm(ContractualimportantEnum.NOT.code);
        contractual.setContractualUser(Long.valueOf(uid));

        return contractualMapper.insert(contractual) > 0;
    }


    /**
     * 获取合同编号
     *
     * @param number        房间号
     * @param community     社区编号
     * @param placeContract 签约地
     * @return 合同编号
     */
    public String createContractingNumber(String number, String community, String placeContract) {

        Calendar calendar = Calendar.getInstance();
        //年
        int year = calendar.get(Calendar.YEAR);
        //月
        int month = calendar.get(Calendar.MONTH) + 1;

        //日
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        //获取合同id
        LambdaQueryWrapper<Contractual> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(Contractual::getContractualId).orderByDesc(Contractual::getContractualId);
        Contractual contractual = contractualMapper.selectOne(wrapper);

        return community
                + "-"
                + placeContract
                + "-"
                + number
                + "-"
                + year
                + (month > 9 ? month : '0' + month)
                + (day > 9 ? day : '0' + day)
                + "00" + (Objects.isNull(contractual) ? 0 : contractual.getContractualId() + 1);
    }


    /**
     * 根据状态查询合同
     *
     * @param dto 参数对象
     * @return 多条数据
     */
    @Override
    public List<ContractualVO> selectPageByState(PageContractualByStateDTO dto) {

        //获取用户id
        String uid = String.valueOf(HttpUtil.getUserLoginInfo().get("uid"));
        dto.setPage((dto.getPage() - 1) * dto.getSize());
        Integer state = ContractualStateEnum.getCodeByMsg(dto.getState());
        return contractualMapper.selectPageByState(
                Long.valueOf(uid), dto.getPage(), dto.getSize(), state);
    }

    /**
     * 根据id查询合同内容
     *
     * @param id 合同id
     * @return 单条数据
     */
    @Override
    public ContractualVO selectDetailById(Long id) {
        String uid = String.valueOf(HttpUtil.getUserLoginInfo().get("uid"));
        LambdaQueryWrapper<Contractual> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Contractual::getContractualUser, Long.valueOf(uid)).eq(Contractual::getContractualId, id);
        Contractual contractual = contractualMapper.selectOne(wrapper);
        ContractualVO info = new ContractualVO();
        Optional.ofNullable(contractual).ifPresent(s -> {
            BeanUtils.copyProperties(contractual, info);
            info.setOccupants(DesensitizationUtil.names(info.getOccupants()));
            info.setPhone(DesensitizationUtil.phone(info.getPhone()));
        });

        return info;
    }

    /**
     * 合同最终确认
     *
     * @param id 合同id
     * @return 是否成功
     */
    @Override
    public Boolean contractFinalConfirm(Long id) {
        //获取用户信息
        String uid = String.valueOf(HttpUtil.getUserLoginInfo().get("uid"));
        LambdaQueryWrapper<Contractual> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Contractual::getContractualUser, Long.valueOf(uid))
                .eq(Contractual::getAssetConfirm,true)
                .eq(Contractual::getImportantConfirm,true)
                .eq(Contractual::getContractualId, id).select(Contractual::getContractualId);
        Contractual contractual = new Contractual();
        contractual.setContractualState(ContractualStateEnum.VALID.code);
        return contractualMapper.update(contractual, wrapper) > 0;
    }

    /**
     * 合同资产确认
     *
     * @param dto 实体对象
     * @return 是否成功
     */
    @Override
    public Boolean contractAssetConfirm(ContractAssetConfirmDTO dto) {

        //获取用户信息
        String uid = String.valueOf(HttpUtil.getUserLoginInfo().get("uid"));
        LambdaQueryWrapper<Contractual> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Contractual::getContractualUser, Long.valueOf(uid))
                .eq(Contractual::getAssetConfirm,ContractualAssetEnum.NOT.code)
                .eq(Contractual::getContractualId,dto.getId()).select(Contractual::getContractualId);
        Contractual contractual = new Contractual();
        contractual.setAssetConfirm(ContractualAssetEnum.YES.code);
        contractual.setDamagedItems(JSON.toJSONString(dto.getList()));
        return  contractualMapper.update(contractual, wrapper) > 0;
    }

    /**
     * 合同重要内容确认确认
     *
     * @param id 合同id
     * @return 是否成功
     */
    @Override
    public Boolean contractImportantConfirm(Long id) {
        //获取用户信息
        String uid = String.valueOf(HttpUtil.getUserLoginInfo().get("uid"));
        LambdaQueryWrapper<Contractual> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Contractual::getContractualUser, Long.valueOf(uid))
                .eq(Contractual::getImportantConfirm,ContractualimportantEnum.NOT.code)
                .eq(Contractual::getContractualId,id).select(Contractual::getContractualId);
        Contractual contractual = new Contractual();
        contractual.setImportantConfirm(ContractualimportantEnum.YES.code);
        return contractualMapper.update(contractual, wrapper) > 0;
    }
}

